/**
* Copyright (c) By zengqh.
*
* This program is just for fun or demo, in the hope that it  
* will be useful, you can redistribute it and/or modify freely.
*
* Time: 2013/02/18
* File: vector3.h
**/

#pragma once

#include "math_def.h"
#include "vector2.h"

namespace HY
{
/// Three-dimensional vector.
class Vector3
{
public:
	/// Construct undefined.
	Vector3()
	{
	}

	/// Copy-construct from another vector.
	Vector3(const Vector3& vector) :
	x_(vector.x_),
		y_(vector.y_),
		z_(vector.z_)
	{
	}

	/// Construct from a two-dimensional vector and the Z coordinate.
	Vector3(const Vector2& vector, float z) :
	x_(vector.x_),
		y_(vector.y_),
		z_(z)
	{
	}

	/// Construct from coordinates.
	Vector3(float x, float y, float z) :
	x_(x),
		y_(y),
		z_(z)
	{
	}

	/// Construct from a float array.
	Vector3(const float* data) :
	x_(data[0]),
		y_(data[1]),
		z_(data[2])
	{
	}

	/// Assign from another vector.
	Vector3& operator = (const Vector3& rhs)
	{
		x_ = rhs.x_;
		y_ = rhs.y_;
		z_ = rhs.z_;
		return *this;
	}

	/// Test for equality with another vector without epsilon.
	bool operator == (const Vector3& rhs) const { return x_ == rhs.x_ && y_ == rhs.y_ && z_ == rhs.z_; }
	/// Test for inequality with another vector without epsilon.
	bool operator != (const Vector3& rhs) const { return x_ != rhs.x_ || y_ != rhs.y_ || z_ != rhs.z_; }
	/// Add a vector.
	Vector3 operator + (const Vector3& rhs) const { return Vector3(x_ + rhs.x_, y_ + rhs.y_, z_ + rhs.z_); }
	/// Return negation.
	Vector3 operator - () const { return Vector3(-x_, -y_, -z_); }
	/// Subtract a vector.
	Vector3 operator - (const Vector3& rhs) const { return Vector3(x_ - rhs.x_, y_ - rhs.y_, z_ - rhs.z_); }
	/// Multiply with a scalar.
	Vector3 operator * (float rhs) const { return Vector3(x_ * rhs, y_ * rhs, z_ * rhs); }
	/// Multiply with a vector.
	Vector3 operator * (const Vector3& rhs) const { return Vector3(x_ * rhs.x_, y_ * rhs.y_, z_ * rhs.z_); }
	/// Divide by a scalar.
	Vector3 operator / (float rhs) const { return Vector3(x_ / rhs, y_ / rhs, z_ / rhs); }
	/// Divide by a vector.
	Vector3 operator / (const Vector3& rhs) const { return Vector3(x_ / rhs.x_, y_ / rhs.y_, z_ / rhs.z_); }

	/// Add-assign a vector.
	Vector3& operator += (const Vector3& rhs)
	{
		x_ += rhs.x_;
		y_ += rhs.y_;
		z_ += rhs.z_;
		return *this;
	}

	/// Subtract-assign a vector.
	Vector3& operator -= (const Vector3& rhs)
	{
		x_ -= rhs.x_;
		y_ -= rhs.y_;
		z_ -= rhs.z_;
		return *this;
	}

	/// Multiply-assign a scalar.
	Vector3& operator *= (float rhs)
	{
		x_ *= rhs;
		y_ *= rhs;
		z_ *= rhs;
		return *this;
	}

	/// Multiply-assign a vector.
	Vector3& operator *= (const Vector3& rhs)
	{
		x_ *= rhs.x_;
		y_ *= rhs.y_;
		z_ *= rhs.z_;
		return *this;
	}

	/// Divide-assign a scalar.
	Vector3& operator /= (float rhs)
	{
		float invRhs = 1.0f / rhs;
		x_ *= invRhs;
		y_ *= invRhs;
		z_ *= invRhs;
		return *this;
	}

	/// Divide-assign a vector.
	Vector3& operator /= (const Vector3& rhs)
	{
		x_ /= rhs.x_;
		y_ /= rhs.y_;
		z_ /= rhs.z_;
		return *this;
	}

	/// Normalize to unit length and return the previous length.
	float Normalize()
	{
		float len = Length();
		if (len >= HY_EPSILON)
		{
			float invLen = 1.0f / len;
			x_ *= invLen;
			y_ *= invLen;
			z_ *= invLen;
		}

		return len;
	}

	/// Return length.
	float Length() const { return sqrtf(x_ * x_ + y_ * y_ + z_ * z_); }
	/// Return squared length.
	float LengthSquared() const { return x_ * x_ + y_ * y_ + z_ * z_; }
	/// Calculate dot product.
	float DotProduct(const Vector3& rhs) const { return x_ * rhs.x_ + y_ * rhs.y_ + z_ * rhs.z_; }
	/// Calculate absolute dot product.
	float AbsDotProduct(const Vector3& rhs) const { return HY::Abs(x_ * rhs.x_) + HY::Abs(y_ * rhs.y_) + HY::Abs(z_ * rhs.z_); }

	/// Calculate cross product.
	Vector3 CrossProduct(const Vector3& rhs) const
	{
		return Vector3(
			y_ * rhs.z_ - z_ * rhs.y_,
			z_ * rhs.x_ - x_ * rhs.z_,
			x_ * rhs.y_ - y_ * rhs.x_
			);
	}

	/// Return absolute vector.
	Vector3 Abs() const { return Vector3(HY::Abs(x_), HY::Abs(y_), HY::Abs(z_)); }
	/// Linear interpolation with another vector.
	Vector3 Lerp(const Vector3& rhs, float t) const { return *this * (1.0f - t) + rhs * t; }
	/// Test for equality with another vector with epsilon.
	bool Equals(const Vector3& rhs) const { return HY::Equals(x_, rhs.x_) && HY::Equals(y_, rhs.y_) && HY::Equals(z_, rhs.z_); }

	/// Return normalized to unit length.
	Vector3 Normalized() const
	{
		float len = Length();
		if (len >= HY_EPSILON)
			return *this * (1.0f / len);
		else
			return *this;
	}

	/// Return float data.
	const float* Data() const { return &x_; }

	/// X coordinate.
	float x_;
	/// Y coordinate.
	float y_;
	/// Z coordinate.
	float z_;

	/// Zero vector.
	static const Vector3 ZERO;
	/// (-1,0,0) vector.
	static const Vector3 LEFT;
	/// (1,0,0) vector.
	static const Vector3 RIGHT;
	/// (0,1,0) vector.
	static const Vector3 UP;
	/// (0,-1,0) vector.
	static const Vector3 DOWN;
	/// (0,0,1) vector.
	static const Vector3 FORWARD;
	/// (0,0,-1) vector.
	static const Vector3 BACK;
	/// (1,1,1) vector.
	static const Vector3 ONE;
};

/// Multiply Vector3 with a scalar.
inline Vector3 operator * (float lhs, const Vector3& rhs) { return rhs * lhs; }
}

